let webim = require('webim_wx.min.js');
let selToID;
let loginInfo;
let accountMode;
let accountType;
let sdkAppID;
let avChatRoomId;
let selType;
let selSess;
let selSessHeadUrl;
//监听大群新消息（普通，点赞，提示，红包）
function onBigGroupMsgNotify(msgList, textMessageCallback, sketchpadDataCallback, groupTipCallback) {
  for (let i = msgList.length - 1; i >= 0; i--) {
    // 遍历消息，按照时间从后往前
    let msg = msgList[i];
        //console.warn(msg);
        webim.Log.warn('receive a new avchatroom group msg: ' + msg.getFromAccountNick());
        //显示收到的消息
        // callback(showMsg(msg));

    handleGroupMessage(msg, textMessageCallback, sketchpadDataCallback, groupTipCallback);
        // console.log('监听大群新消息', msg);
        //showMsg(msg);
    }
}

function handleGroupMessage(msg, textMessageCallback, sketchpadDataCallback, groupTipCallback) {
    console.log('0x256 - handleGroupMessage:', JSON.stringify(msg));
    textMessageCallback && textMessageCallback(showMsg(msg));
  let elems;
  let elem;
  let type;
  let content;
  let ext;
    elems = msg.getElems();//获取消息包含的元素数组
    // 屏蔽自己的白板消息
  console.log(`----> msg.fromAccount: ${msg.fromAccount}, identifier: ${loginInfo.identifier}`);
    if (msg.fromAccount === loginInfo.identifier) {
    console.log('self msg');
        return;
    }
  for (let i in elems) {
        elem = elems[i];
        if (!elem) continue;
        type = elem.getType();//获取元素类型
        console.log('0x256 - type: ' + type);
        content = elem.getContent();//获取元素对象
        if (!content) {
      console.log('content is null');
            continue;
        }
        if (type === 'TIMCustomElem') {
            let ext = content.getExt(); //'白板标签'
            let data = content.getData(); //数据
            if (ext === 'TXWhiteBoardExt') {
                console.log('无压缩数据类型： TXWhiteBoardExt');
                sketchpadDataCallback && sketchpadDataCallback(data);
                break;
            }
        } else if (type === 'TIMCustomFile') {
            console.warn('已压缩压缩数据类型： TXWhiteBoardExt_gzip_');
    } else if (type === 'TIMGroupTipElem') {
      groupTipCallback && groupTipCallback(content);
        }
    }
}

//监听新消息(私聊(包括普通消息、全员推送消息)，普通群(非直播聊天室)消息)事件
//newMsgList 为新消息数组，结构为[Msg]
function onMsgNotify(newMsgList, callback) {
  let newMsg;
  for (let j in newMsgList) {
    // 遍历新消息
        newMsg = newMsgList[j];
        handlderMsg(newMsg, callback);//处理新消息
    }
}

//处理消息（私聊(包括普通消息和全员推送消息)，普通群(非直播聊天室)消息）
function handlderMsg(msg, callback) {
  let fromAccount;
  let fromAccountNick;
  let sessType;
  let subType;
  let contentHtml;

    fromAccount = msg.getFromAccount();
    if (!fromAccount) {
        fromAccount = '';
    }
    fromAccountNick = msg.getFromAccountNick();
    if (!fromAccountNick) {
        fromAccountNick = fromAccount;
    }

    //解析消息
    //获取会话类型
    //webim.SESSION_TYPE.GROUP-群聊，
    //webim.SESSION_TYPE.C2C-私聊，
    sessType = msg.getSession().type();
    //获取消息子类型
    //会话类型为群聊时，子类型为：webim.GROUP_MSG_SUB_TYPE
    //会话类型为私聊时，子类型为：webim.C2C_MSG_SUB_TYPE
    subType = msg.getSubType();

    switch (sessType) {
        case webim.SESSION_TYPE.C2C://私聊消息
            switch (subType) {
                case webim.C2C_MSG_SUB_TYPE.COMMON://c2c普通消息
                    //业务可以根据发送者帐号fromAccount是否为app管理员帐号，来判断c2c消息是否为全员推送消息，还是普通好友消息
                    //或者业务在发送全员推送消息时，发送自定义类型(webim.MSG_ELEMENT_TYPE.CUSTOM,即TIMCustomElem)的消息，在里面增加一个字段来标识消息是否为推送消息
                    contentHtml = convertMsgtoHtml(msg);
          webim.Log.warn('receive a new c2c msg: fromAccountNick=' + fromAccountNick + ', content=' + contentHtml);
                    //c2c消息一定要调用已读上报接口
                    var opts = {
            To_Account: fromAccount, // 好友帐号
            LastedMsgTime: msg.getTime(), // 消息时间戳
                    };
                    webim.c2CMsgReaded(opts);
                    if (callback) {
            let resMsg = {
                            fromAccountNick: fromAccountNick,
              content: contentHtml,
            };
                        callback(resMsg);
                    }

          console.log('收到一条c2c消息(好友消息或者全员推送消息): 发送人=' + fromAccountNick + ', 内容=' + contentHtml);
                    break;
            }
            break;
        case webim.SESSION_TYPE.GROUP://普通群消息，对于直播聊天室场景，不需要作处理
            break;
    }
}

//sdk登录
function sdkLogin(userInfo, listeners, options, avChatRoomId, callback, callbackOptions) {
    //web sdk 登录
  webim.login(
    userInfo,
    listeners,
    options,
        function (identifierNick) {
            //identifierNick为登录用户昵称(没有设置时，为帐号)，无登录态时为空
            webim.Log.info('webim登录成功');
            loginInfo = userInfo;
      setProfilePortrait(
        {
          ProfileItem: [
            {
              Tag: 'Tag_Profile_IM_Nick',
              Value: userInfo.identifierNick,
            },
          ],
            },
            function(ret){
                if(ret) {
                    // 设置昵称失败
            callback &
              callback({
                        errCode: ret.ErrorCode,
                        errMsg: ret.ErrorInfo || '修改昵称失败',
                callback: callbackOptions,
                    });
                    return;
                }
          if (avChatRoomId) applyJoinBigGroup(avChatRoomId); // 加入大群
          callback &
            callback({
                    errCode: 0,
                    errMsg: '',
              callback: callbackOptions,
                });
        },
      );
            //hideDiscussForm();//隐藏评论表单
            //initEmotionUL();//初始化表情
        },
        function (err) {
            console.error(err.ErrorInfo);
            console.log('webim登录失败');
      callback &
        callback({
                errCode: err, 
                errMsg: err.ErrorInfo,
          callback: callbackOptions,
        });
    },
  ); //
}

function setNickName(nickName, callback) {
  setProfilePortrait(
    {
      ProfileItem: [
        {
          Tag: 'Tag_Profile_IM_Nick',
          Value: nickName,
        },
      ],
    },
    function(ret) {
      if (ret) {
        // 设置昵称失败
        callback &
          callback({
            errCode: ret.ErrorCode,
            errMsg: ret.ErrorInfo || '修改昵称失败',
            });
        return;
        }
      loginInfo.identifierNick = nickName;
      callback &
        callback({
          errCode: 0,
          errMsg: '',
        });
    },
  );
}

//修改昵称
function setProfilePortrait(options,callback){
  webim.setProfilePortrait(
    options,
        function(res){
            webim.Log.info('修改昵称成功');
            callback && callback();
        },
        function(ret){
            console.log('修改昵称失败',ret);
            callback && callback(ret);
    },
    );
}

// 创建大群
function createBigGroup(options, callback, callbackOptions) {
  avChatRoomId = options.roomID;
  webim.createGroup(
    {
        GroupId: options.roomID,
        Owner_Account: options.userID,
        Type: 'AVChatRoom', // 默认先是大群
        Name: options.roomName || '',
        MaxMemberCount: 500,
        ApplyJoinOption: 'FreeAccess',
      MemberList: [],
    },
    function(ret) {
        if(ret.ErrorCode) {
            // 建房失败
        callback &&
          callback({
            errCode: ret.ErrorCode,
                errMsg: ret.err_msg,
            callback: callbackOptions,
            });
            return;
        }
        // 建房成功
      callback &&
        callback({
          errCode: 0,
          callback: callbackOptions,
          ret,
        });
    },
    function(ret) {
        // 建房失败
      callback &&
        callback({
            errCode: ret.ErrorCode,
          errMsg: ret.ErrorInfo || 'webim建房失败',
          callback: callbackOptions,
    });
    },
  );
}

//进入大群
function applyJoinBigGroup(groupId, callback, callbackOptions) {
  let options = {
    GroupId: groupId, // 群id
    };
    // 做一些预处理
    avChatRoomId = groupId;
    selSess = null;
    webim.applyJoinBigGroup(
        options,
        function (resp) {
            //JoinedSuccess:加入成功; WaitAdminApproval:等待管理员审批
            if (resp.JoinedStatus && resp.JoinedStatus == 'JoinedSuccess') {
                webim.Log.info('进群成功');
                selToID = groupId;
        callback &&
          callback({
                    errCode: 0,
            callback: callbackOptions,
                });
            } else {
                console.error('进群失败');
        callback &&
          callback({
                    errCode: 999,
                    errMsg: 'IM进群失败',
            callback: callbackOptions,
                });
            }
        },
        function (err) {
            console.error(err.ErrorInfo);
            console.log('进群请求失败', err.ErrorInfo);
      callback &&
        callback({
                errCode: 999,
                errMsg: err.ErrorInfo || 'IM进群失败',
          callback: callbackOptions,
            });
    },
    );
}

//显示消息（群普通+点赞+提示+红包）
function showMsg(msg) {
  let isSelfSend;
  let fromAccount;
  let fromAccountNick;
  let sessType;
  let subType;
  let ul;
  let li;
  let paneDiv;
  let textDiv;
  let nickNameSpan;
  let contentSpan;

    fromAccount = msg.getFromAccount();
    if (!fromAccount) {
        fromAccount = '';
    }
    fromAccountNick = msg.getFromAccountNick();
    if (!fromAccountNick) {
        fromAccountNick = '未知用户';
    }
    //解析消息
    //获取会话类型，目前只支持群聊
    //webim.SESSION_TYPE.GROUP-群聊，
    //webim.SESSION_TYPE.C2C-私聊，
    sessType = msg.getSession().type();
    //获取消息子类型
    //会话类型为群聊时，子类型为：webim.GROUP_MSG_SUB_TYPE
    //会话类型为私聊时，子类型为：webim.C2C_MSG_SUB_TYPE
    subType = msg.getSubType();

    isSelfSend = msg.getIsSend();//消息是否为自己发的
  let content = '';
    switch (subType) {
        case webim.GROUP_MSG_SUB_TYPE.COMMON://群普通消息
            content = convertMsgtoHtml(msg);
            break;
        case webim.GROUP_MSG_SUB_TYPE.REDPACKET://群红包消息
      content = '[群红包消息]' + convertMsgtoHtml(msg);
            break;
        case webim.GROUP_MSG_SUB_TYPE.LOVEMSG://群点赞消息
            //业务自己可以增加逻辑，比如展示点赞动画效果
      content = '[群点赞消息]' + convertMsgtoHtml(msg);
            //展示点赞动画
            showLoveMsgAnimation();
            break;
        case webim.GROUP_MSG_SUB_TYPE.TIP://群提示消息
            // content = "[群提示消息]" + convertMsgtoHtml(msg);
            break;
    }

    return {
        fromAccountNick : fromAccountNick,
    content: content,
  };
}

//把消息转换成Html
function convertMsgtoHtml(msg) {
  let html = '';

  let elems;

  let elem;
   
  let type;

  let content;
    elems = msg.getElems();//获取消息包含的元素数组
  for (let i in elems) {
        elem = elems[i];
        type = elem.getType();//获取元素类型
        content = elem.getContent();//获取元素对象
        switch (type) {
            case webim.MSG_ELEMENT_TYPE.TEXT:
                html += convertTextMsgToHtml(content);
                break;
            case webim.MSG_ELEMENT_TYPE.FACE:
                html += convertFaceMsgToHtml(content);
                break;
            case webim.MSG_ELEMENT_TYPE.IMAGE:
                html += convertImageMsgToHtml(content);
                break;
            case webim.MSG_ELEMENT_TYPE.SOUND:
                html += convertSoundMsgToHtml(content);
                break;
            case webim.MSG_ELEMENT_TYPE.FILE:
                html += convertFileMsgToHtml(content);
                break;
            case webim.MSG_ELEMENT_TYPE.LOCATION://暂不支持地理位置
                //html += convertLocationMsgToHtml(content);
                break;
            case webim.MSG_ELEMENT_TYPE.CUSTOM:
                html += convertCustomMsgToHtml(content);
                break;
            case webim.MSG_ELEMENT_TYPE.GROUP_TIP:
                html += convertGroupTipMsgToHtml(content);
                break;
            default:
                webim.Log.error('未知消息元素类型: elemType=' + type);
                break;
        }
    }
    return webim.Tool.formatHtml2Text(html);
}

//解析文本消息元素
function convertTextMsgToHtml(content) {
    return content.getText();
}
//解析表情消息元素
function convertFaceMsgToHtml(content) {
    return content.getData();
    return content;
  let faceUrl = null;
  let data = content.getData();
  let index = webim.EmotionDataIndexs[data];

  let emotion = webim.Emotions[index];
    if (emotion && emotion[1]) {
        faceUrl = emotion[1];
    }
    if (faceUrl) {
        return "<img src='" + faceUrl + "'/>";
    } else {
        return data;
    }
}
//解析图片消息元素
function convertImageMsgToHtml(content) {
  let smallImage = content.getImage(webim.IMAGE_TYPE.SMALL); // 小图
  let bigImage = content.getImage(webim.IMAGE_TYPE.LARGE); // 大图
  let oriImage = content.getImage(webim.IMAGE_TYPE.ORIGIN); // 原图
    if (!bigImage) {
        bigImage = smallImage;
    }
    if (!oriImage) {
        oriImage = smallImage;
    }
  return (
    "<img src='" +
    smallImage.getUrl() +
    '#' +
    bigImage.getUrl() +
    '#' +
    oriImage.getUrl() +
    "' style='CURSOR: hand' id='" +
    content.getImageId() +
    "' bigImgUrl='" +
    bigImage.getUrl() +
    "' onclick='imageClick(this)' />"
  );
}
//解析语音消息元素
function convertSoundMsgToHtml(content) {
  let second = content.getSecond(); // 获取语音时长
  let downUrl = content.getDownUrl();
    if (webim.BROWSER_INFO.type == 'ie' && parseInt(webim.BROWSER_INFO.ver) <= 8) {
        return '[这是一条语音消息]demo暂不支持ie8(含)以下浏览器播放语音,语音URL:' + downUrl;
    }
    return '<audio src="' + downUrl + '" controls="controls" onplay="onChangePlayAudio(this)" preload="none"></audio>';
}
//解析文件消息元素
function convertFileMsgToHtml(content) {
  let fileSize = Math.round(content.getSize() / 1024);
  return (
    '<a href="' +
    content.getDownUrl() +
    '" title="点击下载文件" ><i class="glyphicon glyphicon-file">&nbsp;' +
    content.getName() +
    '(' +
    fileSize +
    'KB)</i></a>'
  );
}
//解析位置消息元素
function convertLocationMsgToHtml(content) {
    return '经度=' + content.getLongitude() + ',纬度=' + content.getLatitude() + ',描述=' + content.getDesc();
}
//解析自定义消息元素
function convertCustomMsgToHtml(content) {
  let data = content.getData();
  let desc = content.getDesc();
  let ext = content.getExt();
    // return "data=" + data + ", desc=" + desc + ", ext=" + ext;
    return data;
}
//解析群提示消息元素
function convertGroupTipMsgToHtml(content) {
  let WEB_IM_GROUP_TIP_MAX_USER_COUNT = 10;
  let text = '';
  let maxIndex = WEB_IM_GROUP_TIP_MAX_USER_COUNT - 1;
  let opType;
  let opUserId;
  let userIdList;
  let memberCount;
    opType = content.getOpType();//群提示消息类型（操作类型）
    opUserId = content.getOpUserId();//操作人id
    switch (opType) {
        case webim.GROUP_TIP_TYPE.JOIN://加入群
            userIdList = content.getUserIdList();
            //text += opUserId + "邀请了";
            for (var m in userIdList) {
        text += userIdList[m] + ',';
                if (userIdList.length > WEB_IM_GROUP_TIP_MAX_USER_COUNT && m == maxIndex) {
          text += '等' + userIdList.length + '人';
                    break;
                }
            }
            text = text.substring(0, text.length - 1);
      text += '进入房间';
            text += ';{"type":' + opType + ',"userIdList":"' + userIdList.join(',') + '"}';
            //房间成员数加1
            // memberCount = $('#user-icon-fans').html();
            memberCount = parseInt(memberCount) + 1;
            break;
        case webim.GROUP_TIP_TYPE.QUIT://退出群
      text += opUserId + '离开房间';
            text += ';{"type":' + opType + ',"userIdList":"' + opUserId + '"}';
            //房间成员数减1
            if (memberCount > 0) {
                memberCount = parseInt(memberCount) - 1;
            }
            break;
        case webim.GROUP_TIP_TYPE.KICK://踢出群
      text += opUserId + '将';
            userIdList = content.getUserIdList();
            for (var m in userIdList) {
        text += userIdList[m] + ',';
                if (userIdList.length > WEB_IM_GROUP_TIP_MAX_USER_COUNT && m == maxIndex) {
          text += '等' + userIdList.length + '人';
                    break;
                }
            }
      text += '踢出该群';
            break;
        case webim.GROUP_TIP_TYPE.SET_ADMIN://设置管理员
      text += opUserId + '将';
            userIdList = content.getUserIdList();
            for (var m in userIdList) {
        text += userIdList[m] + ',';
                if (userIdList.length > WEB_IM_GROUP_TIP_MAX_USER_COUNT && m == maxIndex) {
          text += '等' + userIdList.length + '人';
                    break;
                }
            }
      text += '设为管理员';
            break;
        case webim.GROUP_TIP_TYPE.CANCEL_ADMIN://取消管理员
      text += opUserId + '取消';
            userIdList = content.getUserIdList();
            for (var m in userIdList) {
        text += userIdList[m] + ',';
                if (userIdList.length > WEB_IM_GROUP_TIP_MAX_USER_COUNT && m == maxIndex) {
          text += '等' + userIdList.length + '人';
                    break;
                }
            }
      text += '的管理员资格';
            break;

        case webim.GROUP_TIP_TYPE.MODIFY_GROUP_INFO://群资料变更
      text += opUserId + '修改了群资料：';
            var groupInfoList = content.getGroupInfoList();
      var type;
      var value;
            for (var m in groupInfoList) {
                type = groupInfoList[m].getType();
                value = groupInfoList[m].getValue();
                switch (type) {
                    case webim.GROUP_TIP_MODIFY_GROUP_INFO_TYPE.FACE_URL:
            text += '群头像为' + value + '; ';
                        break;
                    case webim.GROUP_TIP_MODIFY_GROUP_INFO_TYPE.NAME:
            text += '群名称为' + value + '; ';
                        break;
                    case webim.GROUP_TIP_MODIFY_GROUP_INFO_TYPE.OWNER:
            text += '群主为' + value + '; ';
                        break;
                    case webim.GROUP_TIP_MODIFY_GROUP_INFO_TYPE.NOTIFICATION:
            text += '群公告为' + value + '; ';
                        break;
                    case webim.GROUP_TIP_MODIFY_GROUP_INFO_TYPE.INTRODUCTION:
            text += '群简介为' + value + '; ';
                        break;
                    default:
            text += '未知信息为:type=' + type + ',value=' + value + '; ';
                        break;
                }
            }
            break;

        case webim.GROUP_TIP_TYPE.MODIFY_MEMBER_INFO://群成员资料变更(禁言时间)
      text += opUserId + '修改了群成员资料:';
            var memberInfoList = content.getMemberInfoList();
      var userId;
      var shutupTime;
            for (var m in memberInfoList) {
                userId = memberInfoList[m].getUserId();
                shutupTime = memberInfoList[m].getShutupTime();
        text += userId + ': ';
                if (shutupTime != null && shutupTime !== undefined) {
                    if (shutupTime == 0) {
            text += '取消禁言; ';
                    } else {
            text += '禁言' + shutupTime + '秒; ';
                    }
                } else {
          text += ' shutupTime为空';
                }
                if (memberInfoList.length > WEB_IM_GROUP_TIP_MAX_USER_COUNT && m == maxIndex) {
          text += '等' + memberInfoList.length + '人';
                    break;
                }
            }
            break;
        default:
      text += '未知群提示消息类型：type=' + opType;
            break;
    }
    return text;
}

//tls登录
function tlsLogin() {
    //跳转到TLS登录页面
    console.warn('tlslogin need rewrite');
    // TLSHelper.goLogin({
    //     sdkappid: loginInfo.sdkAppID,
    //     acctype: loginInfo.accountType,
    //     url: window.location.href
    // });
}
//第三方应用需要实现这个函数，并在这里拿到UserSig
function tlsGetUserSig(res) {
    //成功拿到凭证
    if (res.ErrorCode == webim.TLS_ERROR_CODE.OK) {
        //从当前URL中获取参数为identifier的值
    loginInfo.identifier = webim.Tool.getQueryString('identifier');
        //拿到正式身份凭证
        loginInfo.userSig = res.UserSig;
        //从当前URL中获取参数为sdkappid的值
    loginInfo.sdkAppID = loginInfo.appIDAt3rd = Number(webim.Tool.getQueryString('sdkappid'));
        //从cookie获取accountType
    let accountType = webim.Tool.getCookie('accountType');
        if (accountType) {
            loginInfo.accountType = accountType;
            sdkLogin();//sdk登录
        } else {
      location.href = location.href.replace(/\?.*$/gi, '');
        }
    } else {
        //签名过期，需要重新登录
        if (res.ErrorCode == webim.TLS_ERROR_CODE.SIGNATURE_EXPIRATION) {
            tlsLogin();
        } else {
      console.error('[' + res.ErrorCode + ']' + res.ErrorInfo);
        }
    }
}

//单击图片事件
function imageClick(imgObj) {
  let imgUrls = imgObj.src;
  let imgUrlArr = imgUrls.split('#'); // 字符分割
  let smallImgUrl = imgUrlArr[0]; // 小图
  let bigImgUrl = imgUrlArr[1]; // 大图
  let oriImgUrl = imgUrlArr[2]; // 原图
  webim.Log.info('小图url:' + smallImgUrl);
  webim.Log.info('大图url:' + bigImgUrl);
  webim.Log.info('原图url:' + oriImgUrl);
}

//切换播放audio对象
function onChangePlayAudio(obj) {
  if (curPlayAudio) {
    // 如果正在播放语音
    if (curPlayAudio != obj) {
      // 要播放的语音跟当前播放的语音不一样
            curPlayAudio.currentTime = 0;
            curPlayAudio.pause();
            curPlayAudio = obj;
        }
    } else {
        curPlayAudio = obj;//记录当前播放的语音
    }
}

//单击评论图片
function smsPicClick() {
  if (!loginInfo.identifier) {
    // 未登录
    if (accountMode == 1) {
      // 托管模式
            //将account_type保存到cookie中,有效期是1天
            webim.Tool.setCookie('accountType', loginInfo.accountType, 3600 * 24);
            //调用tls登录服务
            tlsLogin();
    } else {
      // 独立模式
            console.error('请填写帐号和票据');
        }
        return;
    } else {
        hideDiscussTool();//隐藏评论工具栏
        showDiscussForm();//显示评论表单
    }
}

//发送消息(普通消息)
function onSendMsg(msg,callback) {
    console.log('accountMode',accountMode);
  if (!loginInfo.identifier) {
    // 未登录
    if (accountMode == 1) {
      // 托管模式
            //将account_type保存到cookie中,有效期是1天
            webim.Tool.setCookie('accountType', loginInfo.accountType, 3600 * 24);
            //调用tls登录服务
            tlsLogin();
    } else {
      // 独立模式
            console.error('请填写帐号和票据');
        }
        return;
    }
    
    if (!selToID) {
    console.error('您还没有进入房间，暂不能聊天');
        return;
    }
    //获取消息内容
  let msgtosend = msg;
  let msgLen = webim.Tool.getStrBytes(msg);

    if (msgtosend.length < 1) {
    console.error('发送的消息不能为空!');
        return;
    }

  let maxLen;
  let errInfo;
    if (selType == webim.SESSION_TYPE.GROUP) {
        maxLen = webim.MSG_MAX_LENGTH.GROUP;
    errInfo = '消息长度超出限制(最多' + Math.round(maxLen / 3) + '汉字)';
    } else {
        maxLen = webim.MSG_MAX_LENGTH.C2C;
    errInfo = '消息长度超出限制(最多' + Math.round(maxLen / 3) + '汉字)';
    }
    if (msgLen > maxLen) {
        console.error(errInfo);
        return;
    }

    if (!selSess) {
        selSess = new webim.Session(selType, selToID, selToID, selSessHeadUrl, Math.round(new Date().getTime() / 1000));
    }
  let isSend = true; // 是否为自己发送
  let seq = -1; // 消息序列，-1表示sdk自动生成，用于去重
  let random = Math.round(Math.random() * 4294967296); // 消息随机数，用于去重
  let msgTime = Math.round(new Date().getTime() / 1000); // 消息时间戳
  let subType; // 消息子类型
    if (selType == webim.SESSION_TYPE.GROUP) {
        //群消息子类型如下：
        //webim.GROUP_MSG_SUB_TYPE.COMMON-普通消息,
        //webim.GROUP_MSG_SUB_TYPE.LOVEMSG-点赞消息，优先级最低
        //webim.GROUP_MSG_SUB_TYPE.TIP-提示消息(不支持发送，用于区分群消息子类型)，
        //webim.GROUP_MSG_SUB_TYPE.REDPACKET-红包消息，优先级最高
        subType = webim.GROUP_MSG_SUB_TYPE.COMMON;
    } else {
        //C2C消息子类型如下：
        //webim.C2C_MSG_SUB_TYPE.COMMON-普通消息,
        subType = webim.C2C_MSG_SUB_TYPE.COMMON;
    }
    var msg = new webim.Msg(selSess, isSend, seq, random, msgTime, loginInfo.identifier, subType, loginInfo.identifierNick);
    //解析文本和表情
  let expr = /\[[^[\]]{1,3}\]/gm;
  let emotions = msgtosend.match(expr);
  let text_obj;
  let face_obj;
  let tmsg;
  let emotionIndex;
  let emotion;
  let restMsgIndex;
    if (!emotions || emotions.length < 1) {
        text_obj = new webim.Msg.Elem.Text(msgtosend);
        msg.addText(text_obj);
  } else {
    // 有表情

    for (let i = 0; i < emotions.length; i++) {
            tmsg = msgtosend.substring(0, msgtosend.indexOf(emotions[i]));
            if (tmsg) {
                text_obj = new webim.Msg.Elem.Text(tmsg);
                msg.addText(text_obj);
            }
            emotionIndex = webim.EmotionDataIndexs[emotions[i]];
            emotion = webim.Emotions[emotionIndex];
            if (emotion) {
                face_obj = new webim.Msg.Elem.Face(emotionIndex, emotions[i]);
                msg.addFace(face_obj);
            } else {
                text_obj = new webim.Msg.Elem.Text(emotions[i]);
                msg.addText(text_obj);
            }
            restMsgIndex = msgtosend.indexOf(emotions[i]) + emotions[i].length;
            msgtosend = msgtosend.substring(restMsgIndex);
        }
        if (msgtosend) {
            text_obj = new webim.Msg.Elem.Text(msgtosend);
            msg.addText(text_obj);
        }
    }

  webim.sendMsg(
    msg,
    function(resp) {
      if (selType == webim.SESSION_TYPE.C2C) {
        // 私聊时，在聊天窗口手动添加一条发的消息，群聊时，长轮询接口会返回自己发的消息
            showMsg(msg);
        }
      webim.Log.info('发消息成功');
        callback && callback();

        //hideDiscussForm();//隐藏评论表单
        //showDiscussTool();//显示评论工具栏
        //hideDiscussEmotion();//隐藏表情
    },
    function(err) {
      webim.Log.error('发消息失败:' + err.ErrorInfo);
      console.error('发消息失败:' + err.ErrorInfo);
    },
  );
}

function sendC2CCustomMsg(toUserID, msg, callback) {
  if (!loginInfo.identifier) {
    // 未登录
    if (accountMode == 1) {
      // 托管模式
            //将account_type保存到cookie中,有效期是1天
            webim.Tool.setCookie('accountType', loginInfo.accountType, 3600 * 24);
            //调用tls登录服务
            tlsLogin();
    } else {
      // 独立模式
            console.error('请填写帐号和票据');
        }
        return;
    } 

   // custom消息
  let data = msg.data || '';
  let desc = msg.desc || '';
  let ext = msg.ext || '';

  let msgLen = webim.Tool.getStrBytes(data);

  let maxLen = webim.MSG_MAX_LENGTH.C2C;
  let errInfo = '消息长度超出限制(最多' + Math.round(maxLen / 3) + '汉字)';
   if (msgLen > maxLen) {
        alert(errInfo);
        return;
    }

  let session = new webim.Session(webim.SESSION_TYPE.C2C, toUserID, toUserID, '', Math.round(new Date().getTime() / 1000));
  let isSend = true; // 是否为自己发送
  let seq = -1; // 消息序列，-1表示sdk自动生成，用于去重
  let random = Math.round(Math.random() * 4294967296); // 消息随机数，用于去重
  let msgTime = Math.round(new Date().getTime() / 1000); // 消息时间戳
  let subType = webim.C2C_MSG_SUB_TYPE.COMMON; // 消息子类型
    
    var msg = new webim.Msg(session, isSend, seq, random, msgTime, loginInfo.identifier, subType, loginInfo.identifierNick);

  let custom_obj = new webim.Msg.Elem.Custom(data, desc, ext);
    msg.addCustom(custom_obj);

    //调用发送消息接口
  webim.sendMsg(
    msg,
    function(resp) {
      webim.Log.info('发自定义消息成功');
        console.log('发自定义消息成功');
      callback &&
        callback({
            errCode: 0,
          errMsg: '',
        });
    },
    function(err) {
        webim.Log.info(err.ErrorInfo);
        console.log('发自定义消息失败:', err);
      callback &&
        callback({
            errCode: -1,
          errMsg: '发自定义消息失败:' + err.ErrorInfo,
    });
    },
  );
}

/**
 * 发送自定义消息
 * 一条custom消息+一条text消息
 * 自定义，用于携带头像与昵称（其他端使用精简版text不能携带）
 */
function sendCustomMsg(msg,callback) {
  if (!loginInfo.identifier) {
    // 未登录
    if (accountMode == 1) {
      // 托管模式
            //将account_type保存到cookie中,有效期是1天
            webim.Tool.setCookie('accountType', loginInfo.accountType, 3600 * 24);
            //调用tls登录服务
            tlsLogin();
    } else {
      // 独立模式
            console.error('请填写帐号和票据');
        }
        return;
    }

    if (!selToID) {
    console.error('您还没有进入房间，暂不能聊天');
        return;
    }
    
    // custom消息
  let data = msg.data || '';
  let desc = msg.desc || '';
  let ext = msg.ext || '';

    var msgLen = webim.Tool.getStrBytes(data);

    if (data.length < 1) {
    alert('发送的消息不能为空!');
        return;
    }
  var maxLen;
  var errInfo;
    if (selType == webim.SESSION_TYPE.C2C) {
        maxLen = webim.MSG_MAX_LENGTH.C2C;
    errInfo = '消息长度超出限制(最多' + Math.round(maxLen / 3) + '汉字)';
    } else {
        maxLen = webim.MSG_MAX_LENGTH.GROUP;
    errInfo = '消息长度超出限制(最多' + Math.round(maxLen / 3) + '汉字)';
    }
    if (msgLen > maxLen) {
        alert(errInfo);
        return;
    }

    // text消息
  let msgtosend = msg.text;
    var msgLen = webim.Tool.getStrBytes(msg.text);

    if (msgtosend.length < 1) {
    console.error('发送的消息不能为空!');
        return;
    }

  var maxLen;
  var errInfo;
    if (selType == webim.SESSION_TYPE.GROUP) {
        maxLen = webim.MSG_MAX_LENGTH.GROUP;
    errInfo = '消息长度超出限制(最多' + Math.round(maxLen / 3) + '汉字)';
    } else {
        maxLen = webim.MSG_MAX_LENGTH.C2C;
    errInfo = '消息长度超出限制(最多' + Math.round(maxLen / 3) + '汉字)';
    }
    if (msgLen > maxLen) {
        console.error(errInfo);
        return;
    }

    if (!selSess) {
        selSess = new webim.Session(selType, selToID, selToID, selSessHeadUrl, Math.round(new Date().getTime() / 1000));
    }
  let isSend = true; // 是否为自己发送
  let seq = -1; // 消息序列，-1表示sdk自动生成，用于去重
  let random = Math.round(Math.random() * 4294967296); // 消息随机数，用于去重
  let msgTime = Math.round(new Date().getTime() / 1000); // 消息时间戳
  let subType; // 消息子类型
    if (selType == webim.SESSION_TYPE.GROUP) {
        //群消息子类型如下：
        //webim.GROUP_MSG_SUB_TYPE.COMMON-普通消息,
        //webim.GROUP_MSG_SUB_TYPE.LOVEMSG-点赞消息，优先级最低
        //webim.GROUP_MSG_SUB_TYPE.TIP-提示消息(不支持发送，用于区分群消息子类型)，
        //webim.GROUP_MSG_SUB_TYPE.REDPACKET-红包消息，优先级最高
        subType = webim.GROUP_MSG_SUB_TYPE.COMMON;
    } else {
        //C2C消息子类型如下：
        //webim.C2C_MSG_SUB_TYPE.COMMON-普通消息,
        subType = webim.C2C_MSG_SUB_TYPE.COMMON;
    }
    var msg = new webim.Msg(selSess, isSend, seq, random, msgTime, loginInfo.identifier, subType, loginInfo.identifierNick);
    
  let custom_obj = new webim.Msg.Elem.Custom(data, desc, ext);
    msg.addCustom(custom_obj);

    //解析文本和表情
  let expr = /\[[^[\]]{1,3}\]/gm;
  let emotions = msgtosend.match(expr);
  let text_obj;
  let face_obj;
  let tmsg;
  let emotionIndex;
  let emotion;
  let restMsgIndex;
    if (!emotions || emotions.length < 1) {
        text_obj = new webim.Msg.Elem.Text(msgtosend);
        msg.addText(text_obj);
  } else {
    // 有表情
    for (let i = 0; i < emotions.length; i++) {
            tmsg = msgtosend.substring(0, msgtosend.indexOf(emotions[i]));
            if (tmsg) {
                text_obj = new webim.Msg.Elem.Text(tmsg);
                msg.addText(text_obj);
            }
            emotionIndex = webim.EmotionDataIndexs[emotions[i]];
            emotion = webim.Emotions[emotionIndex];
            if (emotion) {
                face_obj = new webim.Msg.Elem.Face(emotionIndex, emotions[i]);
                msg.addFace(face_obj);
            } else {
                text_obj = new webim.Msg.Elem.Text(emotions[i]);
                msg.addText(text_obj);
            }
            restMsgIndex = msgtosend.indexOf(emotions[i]) + emotions[i].length;
            msgtosend = msgtosend.substring(restMsgIndex);
        }
        if (msgtosend) {
            text_obj = new webim.Msg.Elem.Text(msgtosend);
            msg.addText(text_obj);
        }
    }
    //调用发送消息接口
  webim.sendMsg(
    msg,
    function(resp) {
      if (selType == webim.SESSION_TYPE.C2C) {
        // 私聊时，在聊天窗口手动添加一条发的消息，群聊时，长轮询接口会返回自己发的消息
            addMsg(msg);
        }
      webim.Log.info('发自定义消息成功');
        console.log('发自定义消息成功');
        callback && callback();
    },
    function(err) {
        webim.Log.info(err.ErrorInfo);
        console.log('发自定义消息失败:',err);
    },
  );
}

//发送消息(群点赞消息)
function sendGroupLoveMsg() {
  if (!loginInfo.identifier) {
    // 未登录
    if (accountMode == 1) {
      // 托管模式
            //将account_type保存到cookie中,有效期是1天
            webim.Tool.setCookie('accountType', loginInfo.accountType, 3600 * 24);
            //调用tls登录服务
            tlsLogin();
    } else {
      // 独立模式
            console.error('请填写帐号和票据');
        }
        return;
    }

    if (!selToID) {
    console.error('您还没有进入房间，暂不能点赞');
        return;
    }

    if (!selSess) {
        selSess = new webim.Session(selType, selToID, selToID, selSessHeadUrl, Math.round(new Date().getTime() / 1000));
    }
  let isSend = true; // 是否为自己发送
  let seq = -1; // 消息序列，-1表示sdk自动生成，用于去重
  let random = Math.round(Math.random() * 4294967296); // 消息随机数，用于去重
  let msgTime = Math.round(new Date().getTime() / 1000); // 消息时间戳
    //群消息子类型如下：
    //webim.GROUP_MSG_SUB_TYPE.COMMON-普通消息,
    //webim.GROUP_MSG_SUB_TYPE.LOVEMSG-点赞消息，优先级最低
    //webim.GROUP_MSG_SUB_TYPE.TIP-提示消息(不支持发送，用于区分群消息子类型)，
    //webim.GROUP_MSG_SUB_TYPE.REDPACKET-红包消息，优先级最高
  let subType = webim.GROUP_MSG_SUB_TYPE.LOVEMSG;

  let msg = new webim.Msg(selSess, isSend, seq, random, msgTime, loginInfo.identifier, subType, loginInfo.identifierNick);
  let msgtosend = 'love_msg';
  let text_obj = new webim.Msg.Elem.Text(msgtosend);
    msg.addText(text_obj);

  webim.sendMsg(
    msg,
    function(resp) {
      if (selType == webim.SESSION_TYPE.C2C) {
        // 私聊时，在聊天窗口手动添加一条发的消息，群聊时，长轮询接口会返回自己发的消息
            showMsg(msg);
        }
      webim.Log.info('点赞成功');
    },
    function(err) {
      webim.Log.error('发送点赞消息失败:' + err.ErrorInfo);
      console.error('发送点赞消息失败:' + err.ErrorInfo);
    },
  );
}
//隐藏评论文本框
function hideDiscussForm() {
    //$(".video-discuss-form").hide();
}
//显示评论文本框
function showDiscussForm() {
    //$(".video-discuss-form").show();
}
//隐藏评论工具栏
function hideDiscussTool() {
    //$(".video-discuss-tool").hide();
}
//显示评论工具栏
function showDiscussTool() {
    //$(".video-discuss-tool").show();
}
//隐藏表情框
function hideDiscussEmotion() {
    //$(".video-discuss-emotion").hide();
    ////$(".video-discuss-emotion").fadeOut("slow");
}
//显示表情框
function showDiscussEmotion() {
    //$(".video-discuss-emotion").show();
    //$(".video-discuss-emotion").fadeIn("slow");
}
//展示点赞动画
function showLoveMsgAnimation() {
    //点赞数加1
    // var loveCount = $('#user-icon-like').html();
    // $('#user-icon-like').html(parseInt(loveCount) + 1);
    // var toolDiv = document.getElementById("video-discuss-tool");
    // var loveSpan = document.createElement("span");
    // var colorList = ['red', 'green', 'blue'];
    // var max = colorList.length - 1;
    // var min = 0;
    // var index = parseInt(Math.random() * (max - min + 1) + min, max + 1);
    // var color = colorList[index];
    // loveSpan.setAttribute('class', 'like-icon zoomIn ' + color);
    // toolDiv.appendChild(loveSpan);
}

//初始化表情
function initEmotionUL() {
    return;
  for (let index in webim.Emotions) {
    let emotions = $('<img>')
      .attr({
        id: webim.Emotions[index][0],
        src: webim.Emotions[index][1],
        style: 'cursor:pointer;',
      })
      .click(function() {
            selectEmotionImg(this);
        });
    $('<li>')
      .append(emotions)
      .appendTo($('#emotionUL'));
    }
}

//打开或显示表情
function showEmotionDialog() {
  if (openEmotionFlag) {
    // 如果已经打开
        openEmotionFlag = false;
        hideDiscussEmotion();//关闭
  } else {
    // 如果未打开
        openEmotionFlag = true;
        showDiscussEmotion();//打开
    }
}
//选中表情
function selectEmotionImg(selImg) {
  $('#send_msg_text').val($('#send_msg_text').val() + selImg.id);
}

// 解散群
function destroyGroup() {
  let options = {
    GroupId: avChatRoomId, // 群id
    Type: 'AVChatRoom',
    };
  webim.destroyGroup(options, function(ret) {
            webim.Log.info('解散群成功');
            selSess = null;
  });
}

//退出大群
function quitBigGroup() {
  let options = {
    GroupId: avChatRoomId, // 群id
    };
    webim.quitBigGroup(
        options,
        function (resp) {
            webim.Log.info('退群成功');
            console.log('IM退群成功');
            selSess = null;
            //webim.Log.error('进入另一个大群:'+avChatRoomId2);
            //applyJoinBigGroup(avChatRoomId2);//加入大群
        },
        function (err) {
            console.error(err.ErrorInfo);
    },
    );
}

//登出
function logout() {
    //登出
  webim.logout(function(resp) {
            webim.Log.info('登出成功');
            console.log('IM登出成功');
            if(loginInfo) {
                loginInfo.identifier = null;
                loginInfo.userSig = null;
            }
            selSess = null;
  });
}

//监听 申请加群 系统消息
function onApplyJoinGroupRequestNotify(notify) {
  webim.Log.warn('执行 加群申请 回调：' + JSON.stringify(notify));
  let timestamp = notify.MsgTime;
  let reportTypeCh = '[申请加群]';
  let content = notify.Operator_Account + '申请加入你的群';
    showGroupSystemMsg(notify.ReportType, reportTypeCh, notify.GroupId, notify.GroupName, content, timestamp);
}

//监听 申请加群被同意 系统消息
function onApplyJoinGroupAcceptNotify(notify) {
  webim.Log.warn('执行 申请加群被同意 回调：' + JSON.stringify(notify));
  let reportTypeCh = '[申请加群被同意]';
  let content = notify.Operator_Account + '同意你的加群申请，附言：' + notify.RemarkInfo;
    showGroupSystemMsg(notify.ReportType, reportTypeCh, notify.GroupId, notify.GroupName, content, notify.MsgTime);
}
//监听 申请加群被拒绝 系统消息
function onApplyJoinGroupRefuseNotify(notify) {
  webim.Log.warn('执行 申请加群被拒绝 回调：' + JSON.stringify(notify));
  let reportTypeCh = '[申请加群被拒绝]';
  let content = notify.Operator_Account + '拒绝了你的加群申请，附言：' + notify.RemarkInfo;
    showGroupSystemMsg(notify.ReportType, reportTypeCh, notify.GroupId, notify.GroupName, content, notify.MsgTime);
}
//监听 被踢出群 系统消息
function onKickedGroupNotify(notify) {
  webim.Log.warn('执行 被踢出群  回调：' + JSON.stringify(notify));
  let reportTypeCh = '[被踢出群]';
  let content = '你被管理员' + notify.Operator_Account + '踢出该群';
    showGroupSystemMsg(notify.ReportType, reportTypeCh, notify.GroupId, notify.GroupName, content, notify.MsgTime);
}
//监听 解散群 系统消息
function onDestoryGroupNotify(notify) {
  webim.Log.warn('执行 解散群 回调：' + JSON.stringify(notify));
  let reportTypeCh = '[群被解散]';
  let content = '群主' + notify.Operator_Account + '已解散该群';
    showGroupSystemMsg(notify.ReportType, reportTypeCh, notify.GroupId, notify.GroupName, content, notify.MsgTime);
}
//监听 创建群 系统消息
function onCreateGroupNotify(notify) {
  webim.Log.warn('执行 创建群 回调：' + JSON.stringify(notify));
  let reportTypeCh = '[创建群]';
  let content = '你创建了该群';
    showGroupSystemMsg(notify.ReportType, reportTypeCh, notify.GroupId, notify.GroupName, content, notify.MsgTime);
}
//监听 被邀请加群 系统消息
function onInvitedJoinGroupNotify(notify) {
  webim.Log.warn('执行 被邀请加群  回调: ' + JSON.stringify(notify));
  let reportTypeCh = '[被邀请加群]';
  let content = '你被管理员' + notify.Operator_Account + '邀请加入该群';
    showGroupSystemMsg(notify.ReportType, reportTypeCh, notify.GroupId, notify.GroupName, content, notify.MsgTime);
}
//监听 主动退群 系统消息
function onQuitGroupNotify(notify) {
  webim.Log.warn('执行 主动退群  回调： ' + JSON.stringify(notify));
  let reportTypeCh = '[主动退群]';
  let content = '你退出了该群';
    showGroupSystemMsg(notify.ReportType, reportTypeCh, notify.GroupId, notify.GroupName, content, notify.MsgTime);
}
//监听 被设置为管理员 系统消息
function onSetedGroupAdminNotify(notify) {
  webim.Log.warn('执行 被设置为管理员  回调：' + JSON.stringify(notify));
  let reportTypeCh = '[被设置为管理员]';
  let content = '你被群主' + notify.Operator_Account + '设置为管理员';
    showGroupSystemMsg(notify.ReportType, reportTypeCh, notify.GroupId, notify.GroupName, content, notify.MsgTime);
}
//监听 被取消管理员 系统消息
function onCanceledGroupAdminNotify(notify) {
  webim.Log.warn('执行 被取消管理员 回调：' + JSON.stringify(notify));
  let reportTypeCh = '[被取消管理员]';
  let content = '你被群主' + notify.Operator_Account + '取消了管理员资格';
    showGroupSystemMsg(notify.ReportType, reportTypeCh, notify.GroupId, notify.GroupName, content, notify.MsgTime);
}
//监听 群被回收 系统消息
function onRevokeGroupNotify(notify) {
  webim.Log.warn('执行 群被回收 回调：' + JSON.stringify(notify));
  let reportTypeCh = '[群被回收]';
  let content = '该群已被回收';
    showGroupSystemMsg(notify.ReportType, reportTypeCh, notify.GroupId, notify.GroupName, content, notify.MsgTime);
}
//监听 用户自定义 群系统消息
function onCustomGroupNotify(notify) {
  webim.Log.warn('执行 用户自定义系统消息 回调：' + JSON.stringify(notify));
  let reportTypeCh = '[用户自定义系统消息]';
  let content = notify.UserDefinedField; // 群自定义消息数据
    showGroupSystemMsg(notify.ReportType, reportTypeCh, notify.GroupId, notify.GroupName, content, notify.MsgTime);
}

//监听 群资料变化 群提示消息
function onGroupInfoChangeNotify(groupInfo) {
  webim.Log.warn('执行 群资料变化 回调： ' + JSON.stringify(groupInfo));
  let groupId = groupInfo.GroupId;
  let newFaceUrl = groupInfo.GroupFaceUrl; // 新群组图标, 为空，则表示没有变化
  let newName = groupInfo.GroupName; // 新群名称, 为空，则表示没有变化
  let newOwner = groupInfo.OwnerAccount; // 新的群主id, 为空，则表示没有变化
  let newNotification = groupInfo.GroupNotification; // 新的群公告, 为空，则表示没有变化
  let newIntroduction = groupInfo.GroupIntroduction; // 新的群简介, 为空，则表示没有变化

    if (newName) {
        //更新群组列表的群名称
        //To do
    webim.Log.warn('群id=' + groupId + '的新名称为：' + newName);
    }
}

//显示一条群组系统消息
function showGroupSystemMsg(type, typeCh, group_id, group_name, msg_content, msg_time) {
  let sysMsgStr =
    '收到一条群系统消息: type=' +
    type +
    ', typeCh=' +
    typeCh +
    ',群ID=' +
    group_id +
    ', 群名称=' +
    group_name +
    ', 内容=' +
    msg_content +
    ', 时间=' +
    webim.Tool.formatTimeStamp(msg_time);
    webim.Log.warn(sysMsgStr);
    console.error(sysMsgStr);
}

function init(opts){
    accountMode = opts.accountMode;
    accountType = opts.accountType;
    sdkAppID = opts.sdkAppID;
    avChatRoomId = opts.avChatRoomId || 0;
    selType = opts.selType;
    selToID = opts.selToID;
}

module.exports = {
    init : init,
    onBigGroupMsgNotify : onBigGroupMsgNotify,
    onMsgNotify : onMsgNotify,
    handlderMsg : handlderMsg,
    sdkLogin : sdkLogin,
  setNickName: setNickName,
    createBigGroup : createBigGroup,
    applyJoinBigGroup : applyJoinBigGroup,
    showMsg : showMsg,
    convertMsgtoHtml : convertMsgtoHtml,
    convertTextMsgToHtml : convertTextMsgToHtml,
    convertFaceMsgToHtml : convertFaceMsgToHtml,
    convertImageMsgToHtml : convertImageMsgToHtml,
    convertSoundMsgToHtml : convertSoundMsgToHtml,
    convertFileMsgToHtml : convertFileMsgToHtml,
    convertLocationMsgToHtml : convertLocationMsgToHtml,
    convertCustomMsgToHtml : convertCustomMsgToHtml,
    convertGroupTipMsgToHtml : convertGroupTipMsgToHtml,
    tlsLogin : tlsLogin,
    tlsGetUserSig : tlsGetUserSig,
    imageClick : imageClick,
    onChangePlayAudio : onChangePlayAudio,
    smsPicClick : smsPicClick,
    onSendMsg : onSendMsg,
    sendCustomMsg : sendCustomMsg,
    sendC2CCustomMsg : sendC2CCustomMsg,
    sendGroupLoveMsg : sendGroupLoveMsg,
    hideDiscussForm : hideDiscussForm,
    showDiscussForm : showDiscussForm,
    hideDiscussTool : hideDiscussTool,
    showDiscussTool : showDiscussTool,
    hideDiscussEmotion : hideDiscussEmotion,
    showDiscussEmotion : showDiscussEmotion,
    showLoveMsgAnimation : showLoveMsgAnimation,
    initEmotionUL : initEmotionUL,
    showEmotionDialog : showEmotionDialog,
    selectEmotionImg : selectEmotionImg,
    quitBigGroup : quitBigGroup,
    destroyGroup : destroyGroup,
    logout : logout,
    onApplyJoinGroupRequestNotify : onApplyJoinGroupRequestNotify,
    onApplyJoinGroupAcceptNotify : onApplyJoinGroupAcceptNotify,
    onApplyJoinGroupRefuseNotify : onApplyJoinGroupRefuseNotify,
    onKickedGroupNotify : onKickedGroupNotify,
    onDestoryGroupNotify : onDestoryGroupNotify,
    onCreateGroupNotify : onCreateGroupNotify,
    onInvitedJoinGroupNotify : onInvitedJoinGroupNotify,
    onQuitGroupNotify : onQuitGroupNotify,
    onSetedGroupAdminNotify : onSetedGroupAdminNotify,
    onCanceledGroupAdminNotify : onCanceledGroupAdminNotify,
    onRevokeGroupNotify : onRevokeGroupNotify,
    onCustomGroupNotify : onCustomGroupNotify,
    onGroupInfoChangeNotify : onGroupInfoChangeNotify,
  showGroupSystemMsg: showGroupSystemMsg,
};
